{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 首先导入一些用到的库。\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-3-10a22b6522ad>:2: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./mnist_dataset/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./mnist_dataset/train-labels-idx1-ubyte.gz\n",
      "Extracting ./mnist_dataset/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./mnist_dataset/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000,)\n",
      "(5000, 784)\n",
      "(5000,)\n",
      "(10000, 784)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "# 先来看看数据长什么样子\n",
    "mnist = input_data.read_data_sets(\"./mnist_dataset\")\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4, idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(mnist.train.labels[idx]))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个float类型的变量用于设置学习率。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Placeholder_6:0\", shape=(?, 784), dtype=float32) Tensor(\"Placeholder_7:0\", shape=(?,), dtype=int64)\n",
      "<tf.Variable 'Variable_8:0' shape=(784, 100) dtype=float32_ref> <tf.Variable 'Variable_9:0' shape=(100,) dtype=float32_ref>\n"
     ]
    }
   ],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784])\n",
    "y = tf.placeholder(\"int64\", [None])\n",
    "\n",
    "print(x, y)\n",
    "\n",
    "learning_rate = tf.placeholder(\"float\")\n",
    "\n",
    "def initialize(shape, stddev=0.1):\n",
    "  return tf.truncated_normal(shape, stddev=0.1) # 产生截断正态分布随机数，取值范围为 [ mean - 2 * stddev, mean + 2 * stddev ]\n",
    "\n",
    "L1_units_count = 100\n",
    "\n",
    "W_1 = tf.Variable(initialize([784, L1_units_count]))\n",
    "b_1 = tf.Variable(initialize([L1_units_count]))\n",
    "print(W_1, b_1)  # W_1 [784, 100], 输出到第一个隐层，第一个隐层神经元 100 个\n",
    "\n",
    "logits_1 = tf.matmul(x, W_1) + b_1\n",
    "output_1 = tf.nn.relu(logits_1) # 第一个隐层激活函数采用relu\n",
    "\n",
    "L2_units_count = 10 \n",
    "W_2 = tf.Variable(initialize([L1_units_count, L2_units_count]))\n",
    "b_2 = tf.Variable(initialize([L2_units_count]))\n",
    "logits_2 = tf.matmul(output_1, W_2) + b_2  # 第一个隐层的relu输出到输出层，输出神经元10个\n",
    "\n",
    "logits = logits_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits, 这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为可以根据需要设定。\n",
    "\n",
    "试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "softmax:\n",
    "    把我们定义的线性函数的输出转换成我们想要的格式，也就是关于10个数字类的概率分布。\n",
    "    因此，给定一张图片，它对于每一个数字的吻合度可以被softmax函数转换成为一个概率值\n",
    "'''\n",
    "\n",
    "'''\n",
    "交叉熵:\n",
    "    我们通常定义指标来表示一个模型是坏的，这个指标称为成本（cost）或损失（loss），然后尽量最小化这个指标\n",
    "    交叉熵是用来衡量我们的预测用于描述真相的低效性\n",
    "'''\n",
    "\n",
    "'''\n",
    "tf.reduce_mean: \n",
    "    函数用于计算张量tensor沿着指定的数轴（tensor的某一维度）上的的平均值，主要用作降维或者计算tensor（图像）的平均值。\n",
    "    计算张量的所有元素的总和\n",
    "    注意，这里的交叉熵不仅仅用来衡量单一的一对预测和真实值，而是所有100幅图片的交叉熵的总和。\n",
    "    对于100个数据点的预测表现比单一数据点的表现能更好地描述我们的模型的性能。\n",
    "'''\n",
    "\n",
    "'''\n",
    "GradientDescentOptimizer:\n",
    "    因为TensorFlow拥有一张描述你各个计算单元的图，\n",
    "    它可以自动地使用反向传播算法(backpropagation algorithm)来有效地确定你的变量是如何影响你想要最小化的那个成本值的。\n",
    "    然后，TensorFlow会用你选择的优化算法来不断地修改变量以降低成本。\n",
    "    TensorFlow用梯度下降算法（gradient descent algorithm）以learning_rate的学习速率最小化交叉熵。\n",
    "'''\n",
    "\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=learning_rate).minimize(cross_entropy_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布， 要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "tf.argmax 是一个非常有用的函数，它能给出某个tensor对象在某一维上的其数据最大值所在的索引值。\n",
    "由于标签向量是由0,1组成，因此最大值1所在的索引位置就是类别标签，比如tf.argmax(y,1)返回的是模型对于任一输入x预测到的标签值，\n",
    "而 tf.argmax(y_,1) 代表正确的标签，我们可以用 tf.equal 来检测我们的预测是否真实标签匹配(索引位置一样表示匹配)。\n",
    "'''\n",
    "\n",
    "pred = tf.nn.softmax(logits)\n",
    "\n",
    "'''\n",
    "这行代码会给我们一组布尔值。为了确定正确预测项的比例，我们可以把布尔值转换成浮点数，然后取平均值。\n",
    "例如，[True, False, True, True] 会变成 [1,0,1,1] ，取平均值后得到 0.75.\n",
    "\n",
    "用于测试数据集上面的正确率。\n",
    "'''\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), y)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# saver用于保存或恢复训练的模型。\n",
    "batch_size = 32\n",
    "trainig_step = 1000\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.44292, the validation accuracy is 0.865\n",
      "after 200 training steps, the loss is 0.253214, the validation accuracy is 0.906\n",
      "after 300 training steps, the loss is 0.429256, the validation accuracy is 0.9118\n",
      "after 400 training steps, the loss is 0.222413, the validation accuracy is 0.9242\n",
      "after 500 training steps, the loss is 0.106036, the validation accuracy is 0.9444\n",
      "after 600 training steps, the loss is 0.133696, the validation accuracy is 0.944\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/saver.py:966: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps, the loss is 0.232784, the validation accuracy is 0.9484\n",
      "after 800 training steps, the loss is 0.241391, the validation accuracy is 0.945\n",
      "after 900 training steps, the loss is 0.313694, the validation accuracy is 0.939\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9538\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "    使用一小部分的随机数据来进行训练被称为随机训练（stochastic training）- 在这里更确切的说是随机梯度下降训练。\n",
    "    在理想情况下，我们希望用我们所有的数据来进行每一步的训练，因为这能给我们更好的训练结果，但显然这需要很大的计算开销。\n",
    "    所以，每一次训练我们可以使用不同的数据子集，这样做既可以减少计算开销，又可以最大化地学习到数据集的总体特性。\n",
    "    这里使用32个作为子集\n",
    "'''\n",
    "\n",
    "'''\n",
    "0.9538,这个结果不算话，因为仅仅使用了一个非常简单的模型，没有对初始化、正则化等做处理优化\n",
    "'''\n",
    "\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss = sess.run(\n",
    "            [optimizer, cross_entropy_loss],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                learning_rate: 0.3\n",
    "            })\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面，用我们训练的模型做一个测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-900\n",
      "0.875\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "我们计算所学习到的模型在测试数据集上面的正确率。\n",
    "'''\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16]\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(mnist.test.labels[idx],\n",
    "                                                  order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
